home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / HENSA / MEMORY / CHECKCMOS.ARC / !CheckCMOS / c / !Runimage
Text File  |  1993-07-12  |  30KB  |  1,222 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. #include "menu.h"
  7. #include "resspr.h"
  8. #include "colourtran.h"
  9. #include "bbc.h"
  10. #include "event.h"
  11. #include "win.h"
  12. #include "dbox.h"
  13. #include "werr.h"
  14. #include "wimp.h"
  15. #include "res.h"
  16. #include "visdelay.h"
  17. #include "template.h"
  18. #include "wimpt.h"
  19. #include "os.h"
  20. #include "swis.h"
  21. #include "kernel.h"
  22. #include "msgs.h"
  23.  
  24. #define CMOS_preferences "<CheckCMOS$Dir>.CMOS_Pref"
  25. #define Program_Settings "<CheckCMOS$Dir>.Settings"
  26.  
  27. char Task_Name[10];
  28.  
  29. typedef int mask;
  30.  
  31. mask prog_settings = 0x00;
  32.  
  33. #define READATTR  5
  34. #define FILEFOUND 1
  35. #define UNUSED(X) (X=X)
  36.  
  37. #define max(X,Y) (((X)>(Y))?(X):(Y))
  38. #define min(X,Y) (((X)<(Y))?(X):(Y))
  39.  
  40. static wimp_w control_handle;              /* window handle */
  41. static wimp_w cmos_items_handle;           /* window handle */
  42.  
  43. typedef char cmos_ram[240];
  44.  
  45. typedef struct
  46. {
  47.   mask         ignore;
  48.   char         name[100];
  49.   int          start_byte;
  50.   int          start_bit;
  51.   int          end_byte;
  52.   int          end_bit;
  53.   int          old_value;
  54.   int          new_value;
  55.   char         *cmos_error;
  56.   BOOL         needs_reset;
  57. } cmos_item;
  58.  
  59. BOOL file_exists ( char *filename )
  60. {
  61.   _kernel_osfile_block finfo;
  62.  
  63.   return (_kernel_osfile(READATTR, filename, &finfo) == FILEFOUND);
  64. }
  65.  
  66. void read_line (FILE *index, char *item, int buffsize)
  67. { 
  68.   int i;    
  69.   char c;
  70.  
  71.   c = fgetc(index);
  72.   for (i=0;(i<(buffsize-1)) && (c!=10) && !feof(index);i++)
  73.     {
  74.       item[i]=c;
  75.       c = fgetc(index);
  76.     }           
  77.   item[i]=0;    
  78. }
  79.  
  80. struct {
  81.   char ignore_name[100];
  82. } ignore_item[32];
  83.   
  84. void initialize_Ignore_masks (void)
  85. {
  86.   int i;
  87.  
  88.   for (i=0;i<=31;i++)
  89.     ignore_item[i].ignore_name[0]=0;
  90. }
  91.  
  92. mask find_or_create_mask ( char *ignore_str )
  93. {                        
  94.   int i;
  95.  
  96.   if (strlen(ignore_str)==0)
  97.     return 0;
  98.  
  99.   for (i=0;i<=31;i++)
  100.     {
  101.       if (strcmp(ignore_item[i].ignore_name,ignore_str)==0)
  102.         return (1<<i);
  103.       if (strlen(ignore_item[i].ignore_name)==0)
  104.         {               
  105.           strcpy (ignore_item[i].ignore_name,ignore_str);
  106.           return (1<<i);
  107.         }
  108.     }
  109.  
  110.   werr (TRUE ,msgs_lookup("ER6:Too many Ignore groups (max 32 unique groups)"));
  111.   exit (0);
  112.   return 0;
  113. }
  114.  
  115. mask find_mask ( char *ignore_str )
  116. {                        
  117.   int i;
  118.  
  119.   if (strlen(ignore_str)==0)
  120.     return 0;
  121.  
  122.   for (i=0;i<=31;i++)
  123.     {
  124.       if (strcmp(ignore_item[i].ignore_name,ignore_str)==0)
  125.         return (1<<i);
  126.     }
  127.  
  128.   return 0;
  129. }
  130.  
  131. char *get_ignore_name ( int ignore_number )
  132. {
  133.   return (ignore_item[ignore_number].ignore_name);
  134. }
  135.  
  136. #define max_cmos_items 200
  137. cmos_item cmos_item_array[max_cmos_items];
  138. cmos_ram current_cmos;
  139. cmos_ram preferred_cmos;
  140.  
  141. void read_cmos (cmos_ram *current_cmos)
  142. {
  143.   int i;
  144.   int temp;
  145.  
  146.   for (i=0;i<=239;i++)
  147.     {
  148.       wimpt_noerr(os_byte(161,&i,&temp));
  149.       (*current_cmos)[i] = temp;
  150.     }
  151. }
  152.  
  153. void modify_cmos (cmos_ram old_cmos, cmos_ram new_cmos)
  154. {
  155.   int i;
  156.   int temp;
  157.  
  158.   visdelay_begin ();
  159.   for (i=0;i<=239;i++)
  160.     {
  161.       if (new_cmos[i] != old_cmos[i])
  162.         {
  163.           temp = new_cmos[i];
  164.           wimpt_noerr(os_byte(162,&i,&temp));
  165.         }
  166.       visdelay_percent (100*i/240);
  167.     }
  168.   visdelay_end ();
  169. }
  170.  
  171. void read_cmos_preferences (cmos_ram *preferred_cmos)
  172. {
  173.   os_filestr f;
  174.  
  175.   f.action = 16;                                     /* load file */
  176.   f.name = CMOS_preferences;
  177.   f.loadaddr = (int)preferred_cmos;
  178.   f.execaddr = 0;
  179.   wimpt_noerr(os_file(&f));
  180. }
  181.  
  182. void save_cmos_preferences (cmos_ram preferred_cmos)
  183. {
  184.   os_filestr f;
  185.  
  186.   f.action = 10;                                    /* save file */
  187.   f.name = CMOS_preferences;
  188.   f.loadaddr = 0xFF2;
  189.   f.start = (int)preferred_cmos;
  190.   f.end   = (int)preferred_cmos+240;
  191.   wimpt_noerr(os_file(&f));
  192. }
  193.  
  194. void read_prog_settings (mask *prog_settings)
  195. {                 
  196.   if (file_exists (Program_Settings))
  197.     {
  198.       FILE *fh;
  199.  
  200.       fh = fopen (Program_Settings,"r");
  201.       while (!feof(fh))
  202.         {
  203.           char name[100];
  204.  
  205.           read_line (fh,name,sizeof(name));
  206.           *prog_settings |= find_mask (name);
  207.         }
  208.       fclose (fh);
  209.     }
  210. }
  211.  
  212. void save_prog_settings (mask prog_settings)
  213. {
  214.   FILE *fh;
  215.   int i;
  216.        
  217.   fh=fopen(Program_Settings,"w");
  218.   for (i=0;i<=31;i++)
  219.     if (prog_settings & (1<<i))
  220.       fprintf (fh,"%s\n",get_ignore_name(i));
  221.   fclose (fh);
  222. }
  223.  
  224.                               
  225. cmos_ram cmos_bits;
  226.  
  227. void initialize_cmos_bits ( void )
  228. {
  229.   int byte;
  230.  
  231.   for (byte=0;byte<=239;byte++)
  232.     cmos_bits[byte] = 0x00;
  233. }
  234.   
  235. void allocate_cmos_bit ( int byte, int bit )
  236. {
  237.   if (cmos_bits[byte] & (1<<bit))
  238.     {
  239.       werr (TRUE ,msgs_lookup("ER2:CMOS Byte %d, Bit %d allocated twice"),byte,bit);
  240.       exit (0);
  241.     }
  242.   cmos_bits[byte] |= (1<<bit);
  243. }
  244.  
  245. void allocate_cmos_byte ( int byte )
  246. {
  247.   if (cmos_bits[byte])
  248.     {
  249.       int bit;
  250.  
  251.       for (bit=0;bit<=7;bit++)
  252.         if (cmos_bits[byte] & (1<<bit))
  253.           {
  254.             werr (TRUE ,msgs_lookup("ER3:CMOS Byte %d allocated twice"),byte);
  255.             exit (0);
  256.           }
  257.     }
  258.   cmos_bits[byte] = 0xFF;
  259. }
  260.  
  261. void allocate_cmos_bits ( int start_byte, int start_bit, int end_byte, int end_bit )
  262. {
  263.   int byte, bit;
  264.                            
  265.   if (start_byte==end_byte)
  266.     {
  267.       if ((start_bit!=0) || (end_bit!=7))
  268.         {
  269.           for (bit=start_bit;bit<=end_bit;bit++)
  270.             allocate_cmos_bit (start_byte,bit);
  271.         }
  272.       else
  273.         allocate_cmos_byte (start_byte);
  274.     }
  275.   else
  276.     {
  277.       if (start_bit!=0)
  278.         for (bit=start_bit;bit<=7;bit++)
  279.           allocate_cmos_bit (start_byte,bit);
  280.       else
  281.         allocate_cmos_byte (start_byte);
  282.  
  283.       for (byte=start_byte+1;byte<=end_byte-1;byte++)
  284.         allocate_cmos_byte (byte);
  285.  
  286.       if (end_bit!=7)
  287.         for (bit=0;bit<=end_bit;bit++)
  288.           allocate_cmos_bit (end_byte,bit);
  289.       else
  290.         allocate_cmos_byte (end_byte);
  291.     }
  292. }
  293.  
  294. void check_cmos_allocations ( void )
  295. {
  296.   int byte, bit;
  297.                            
  298.   for (byte=0;byte<=239;byte++)
  299.     if (cmos_bits[byte]!=0xFF)
  300.       for (bit=0;bit<=7;bit++)
  301.         if ((cmos_bits[byte] & (1<<bit))==0)
  302.           {
  303.             werr (TRUE ,msgs_lookup("ER4:CMOS Byte %d, Bit %d not allocated"),byte,bit);
  304.             exit (0);
  305.           }
  306. }
  307.  
  308. int cmos_item_insert_point = 0;
  309.  
  310. void initialize_cmos_item ( char *ignore_str, char *item_name, int start_byte, int start_bit, int end_byte, int end_bit, BOOL needs_reset )
  311. {        
  312.   mask ignore;
  313.                 
  314.   allocate_cmos_bits (start_byte, start_bit, end_byte, end_bit);
  315.                                             
  316.   ignore = find_or_create_mask (ignore_str);
  317.  
  318.   if (cmos_item_insert_point==max_cmos_items)
  319.     {
  320.       werr (TRUE ,msgs_lookup("ER10:Program limitation - too many CMOS items described"));
  321.       exit (0);
  322.     }
  323.   cmos_item_array[cmos_item_insert_point].ignore      = ignore;
  324.   strcpy (cmos_item_array[cmos_item_insert_point].name,item_name);
  325.   cmos_item_array[cmos_item_insert_point].start_byte  = start_byte;
  326.   cmos_item_array[cmos_item_insert_point].start_bit   = start_bit;
  327.   cmos_item_array[cmos_item_insert_point].end_byte    = end_byte;
  328.   cmos_item_array[cmos_item_insert_point].end_bit     = end_bit;
  329.   cmos_item_array[cmos_item_insert_point].cmos_error  = NULL;
  330.   cmos_item_array[cmos_item_insert_point].needs_reset = needs_reset;
  331.   cmos_item_insert_point++;
  332.   strcpy(cmos_item_array[cmos_item_insert_point].name,"");
  333. }
  334.  
  335. void get_token ( char **token, char **temp)
  336. {
  337.   while (**temp==' ') *temp=*temp+1;
  338.   *token = *temp;
  339.   while ((**temp!=' ')&&(**temp!=0)) *temp=*temp+1;
  340.   if (**temp==' ')
  341.     {
  342.       **temp=0;
  343.       *temp=*temp+1;
  344.     }
  345.   while (**temp==' ') *temp=*temp+1;
  346. }
  347.  
  348. BOOL convert_num ( char *s, int *num, int maxnum )
  349. {
  350.   int i;
  351.  
  352.   for (i=0;i<strlen(s);i++)
  353.     if ((s[i]<'0')||(s[i]>'9'))
  354.       return FALSE;
  355.  
  356.   *num = 0;
  357.   for (i=0;i<strlen(s);i++)
  358.     {
  359.       *num = (*num)*10 + (s[i]-'0');
  360.  
  361.       if (*num>maxnum)
  362.         return FALSE;
  363.     }
  364.  
  365.   return TRUE;
  366. }
  367.  
  368. void uppercase ( char *s )
  369. {
  370.   int i;
  371.   
  372.   for (i=0;i<strlen(s);i++)
  373.     if ((s[i]>='a')&&(s[i]<='z'))
  374.       s[i] = s[i] - 'a' + 'A';
  375. }
  376.  
  377. void uppercase_word ( char *s )
  378. {
  379.   int i;
  380.   
  381.   for (i=0;(i<strlen(s)) && (s[i]!=':');i++)
  382.     if ((s[i]>='a')&&(s[i]<='z'))
  383.       s[i] = s[i] - 'a' + 'A';
  384. }
  385.  
  386. char *token_lookup (char *s)
  387. {
  388.   static char temp[256];
  389.   char *msgptr;
  390.  
  391.   msgptr = msgs_lookup(s);
  392.   strcpy(temp,msgptr);
  393.   uppercase(temp);
  394.   return temp;
  395. }
  396.  
  397. void parse_location_line (char *line, int *start_byte, int *start_bit, int *end_byte, int *end_bit, BOOL *error)
  398. {     
  399.   char *temp = line;          
  400.   char *token;
  401.   BOOL first_bit_specified = FALSE;
  402.                  
  403.   uppercase(line);
  404.  
  405.   /* BYTE <num> [BIT <num>] [TO [BYTE <num>] [BIT <num>]] */
  406.   /* TO must be followed by a BYTE or BIT */
  407.   /* Anomily: BYTE 5 BIT 3 ... means only bit 3 */
  408.  
  409.   *error=FALSE;
  410.   get_token (&token,&temp);
  411.   if (strcmp(token,token_lookup("LANG1:BYTE"))==0)
  412.     {
  413.       get_token (&token,&temp);
  414.       if (!convert_num (token,start_byte,240))
  415.         {
  416.           *error = TRUE;
  417.           return;
  418.         }
  419.       get_token (&token,&temp);
  420.       if (strcmp(token,token_lookup("LANG2:BIT"))==0)
  421.         {
  422.           get_token (&token,&temp);
  423.           if (!convert_num (token,start_bit,7))
  424.             {
  425.               *error = TRUE;
  426.               return;
  427.             }
  428.           get_token (&token,&temp);
  429.           first_bit_specified = TRUE;
  430.         }
  431.       else
  432.         *start_bit = 0;
  433.       if (strcmp(token,token_lookup("LANG3:TO"))==0)
  434.         {
  435.           get_token (&token,&temp);
  436.           if (strcmp(token,token_lookup("LANG1:BYTE"))==0)
  437.             {
  438.               get_token (&token,&temp);
  439.               if (!convert_num (token,end_byte,240))
  440.                 {
  441.                   *error = TRUE;
  442.                   return;
  443.                 }
  444.               get_token (&token,&temp);
  445.               if (strcmp(token,token_lookup("LANG2:BIT"))==0)
  446.                 {
  447.                   get_token (&token,&temp);
  448.                   if (!convert_num (token,end_bit,7))
  449.                     {
  450.                       *error = TRUE;
  451.                       return;
  452.                     }
  453.                   get_token (&token,&temp);
  454.                 }
  455.               else
  456.                 *end_bit = 7;
  457.             }
  458.           else
  459.           if (strcmp(token,token_lookup("LANG2:BIT"))==0)
  460.             {
  461.               *end_byte = *start_byte;
  462.               get_token (&token,&temp);
  463.               if (!convert_num (token,end_bit,7))
  464.                 {
  465.                   *error = TRUE;
  466.                   return;
  467.                 }
  468.               get_token (&token,&temp);
  469.             }
  470.           else
  471.             {
  472.               *error = TRUE;
  473.               return;
  474.             }
  475.         }
  476.       else
  477.         {
  478.           *end_byte = *start_byte;   
  479.           if (first_bit_specified)
  480.             *end_bit = *start_bit;
  481.           else
  482.             *end_bit = 7;    
  483.         }
  484.       if (strlen(token)!=0)
  485.         *error = TRUE;
  486.     }
  487.   else
  488.     *error = TRUE;
  489. }
  490.  
  491. void trim_ends (char *line)
  492. {
  493.   char *start = line;
  494.   char *end;   
  495.  
  496.   while (*start==' ') start++;
  497.  
  498.   memmove (line,start,strlen(start)+1);
  499.  
  500.   end = line+strlen(line)-1;
  501.   while (*end==' ') *end-- = 0;
  502. }
  503.                                                             
  504. int os_version (void)
  505. {
  506.   _kernel_swi_regs reg;
  507.  
  508.   reg.r[0] = 129;  /* Read keyboard for information  */
  509.   reg.r[1] = 0;    /* Read the OS version identifier */
  510.   reg.r[2] = 0xFF;  
  511.   _kernel_swi (OS_Byte,®,®);
  512.  
  513.   return reg.r[1];
  514. }
  515.  
  516. void os_not_supported (void)
  517. {
  518.   werr (TRUE ,msgs_lookup("ER9:Risc OS 2.00 to Risc OS 3.11 only supported"));
  519.   exit (0);
  520. }
  521.  
  522. void init_cmos_array (void)
  523. {
  524.   FILE *fh;
  525.   int LineNo = 0;
  526.   char CMOS_Table[50];
  527.  
  528.   switch (os_version())
  529.     {
  530.       case 0xA0 : os_not_supported();
  531.       case 0xA1 : 
  532.       case 0xA2 : sprintf (CMOS_Table,"<CheckCMOS$Dir>.RISCOS2"); break;
  533.       case 0xA3 : 
  534.       case 0xA4 : sprintf (CMOS_Table,"<CheckCMOS$Dir>.RISCOS3"); break;
  535.       default   : os_not_supported();
  536.     }
  537.  
  538.   initialize_cmos_bits();
  539.   initialize_Ignore_masks();
  540.  
  541.   if (!file_exists (CMOS_Table))
  542.     {
  543.       werr (TRUE ,msgs_lookup("ER7:CMOS Table could not be found (to create one see docs)"));
  544.       exit (0);
  545.     }
  546.  
  547.   fh = fopen (CMOS_Table,"r");
  548.   while (!feof(fh))
  549.     {
  550.       typedef struct
  551.        {
  552.          char group[100];
  553.          char name[100];
  554.          int  start_byte;
  555.          int  start_bit;
  556.          int  end_byte;
  557.          int  end_bit;
  558.          BOOL needs_reset;
  559.        } cmos_desc;
  560.  
  561.       char line[100]="";     
  562.       cmos_desc new_item;
  563.       BOOL error;
  564.  
  565.       *new_item.group=0;
  566.       new_item.needs_reset=TRUE;
  567.       
  568.       while ((strlen(line)==0) && !feof(fh))
  569.         {
  570.           read_line (fh,line,sizeof(line));
  571.           LineNo++;
  572.         }                                   
  573.  
  574.       if (!feof(fh))
  575.         {
  576.           parse_location_line (line,&new_item.start_byte,&new_item.start_bit,&new_item.end_byte,&new_item.end_bit,&error);
  577.           if (error)
  578.             {
  579.               werr (TRUE ,msgs_lookup("ER8:Parse Error in CMOS_Table, line %d"),LineNo);
  580.               exit (0);
  581.             }
  582.           read_line (fh,new_item.name,sizeof(new_item.name));
  583.           LineNo++;
  584.           read_line (fh,line,sizeof(line));
  585.           LineNo++;
  586.           trim_ends (line);
  587.           uppercase_word (line);
  588.           while (strcmp(line,token_lookup("LANG7:End"))!=0)
  589.             {
  590.               if ((strlen(line)==0)&&feof(fh))
  591.                 {
  592.                   werr (TRUE ,msgs_lookup("ER8:Parse Error in CMOS_Table, line %d"),LineNo);
  593.                   exit (0);
  594.                 }                 
  595.               
  596.               {
  597.                 if (strncmp(line,token_lookup("LANG4:Group"),strlen(token_lookup("LANG4:Group")))==0)
  598.                   {
  599.                     strcpy (new_item.group,line+strlen(token_lookup("LANG4:Group"))+1);
  600.                     trim_ends (new_item.group);
  601.                   }
  602.                 else
  603.                 if (strcmp(line,token_lookup("LANG6:Needs reset to take effect"))==0)
  604.                   new_item.needs_reset = TRUE;
  605.                 else
  606.                 if (strcmp(line,token_lookup("LANG5:Has instant effect"))==0)
  607.                   new_item.needs_reset = FALSE;
  608.                 else
  609.                   {
  610.                     werr (TRUE ,msgs_lookup("ER8:Parse Error in CMOS_Table, line %d"),LineNo);
  611.                     exit (0);
  612.                   }
  613.               }
  614.               read_line (fh,line,sizeof(line));
  615.               trim_ends (line);
  616.               uppercase_word (line);
  617.               LineNo++;
  618.             }
  619.  
  620.           initialize_cmos_item (new_item.group,new_item.name,new_item.start_byte,new_item.start_bit,new_item.end_byte,new_item.end_bit,new_item.needs_reset);
  621.         }
  622.     }
  623.   fclose (fh);
  624.   
  625.   check_cmos_allocations();                                                                        
  626. }
  627.  
  628. void perform_cmos_check ( BOOL *cmos_changed )
  629. {
  630.   int i;
  631.  
  632.   *cmos_changed = FALSE;
  633.   for (i=0;i<240;i++)
  634.     if (current_cmos[i] != preferred_cmos[i])
  635.       *cmos_changed = TRUE;
  636. }
  637.  
  638. void set_error_message ( int target_item, char *message )
  639. {
  640.   int item;
  641.  
  642.   if ( prog_settings & cmos_item_array[target_item].ignore )
  643.     return;
  644.  
  645.   for (item=0;strlen(cmos_item_array[item].name)!=0;item++)
  646.     if (strcmp(cmos_item_array[item].cmos_error,message)==0)
  647.       return;
  648.  
  649.   cmos_item_array[target_item].cmos_error = message;
  650. }
  651.  
  652.  
  653. void collate_changes_to_cmos (cmos_ram current_cmos, cmos_ram preferred_cmos, int *changes)
  654. {
  655.   int item;
  656.  
  657.   for (item=0;strlen(cmos_item_array[item].name)!=0;item++)
  658.     {
  659.       int byte, bit;
  660.       BOOL ok = TRUE;
  661.       char mask;
  662.  
  663.       if (cmos_item_array[item].start_byte == cmos_item_array[item].end_byte)
  664.         {        
  665.           mask = 0;
  666.           for (bit=cmos_item_array[item].start_bit;bit<=cmos_item_array[item].end_bit;bit++)
  667.             mask |= (1<<bit);
  668.           if ((preferred_cmos[cmos_item_array[item].start_byte] & mask) != (current_cmos[cmos_item_array[item].start_byte] & mask))
  669.             ok = FALSE;
  670.         }
  671.       else
  672.         {
  673.           mask = 0;
  674.           for (bit=cmos_item_array[item].start_bit;bit<=7;bit++)
  675.             mask |= (1<<bit);
  676.           if ((preferred_cmos[cmos_item_array[item].start_byte] & mask) != (current_cmos[cmos_item_array[item].start_byte] & mask))
  677.             ok = FALSE;
  678.  
  679.           for (byte=cmos_item_array[item].start_byte+1;byte<=cmos_item_array[item].end_byte-1;byte++)
  680.             if (preferred_cmos[byte] != current_cmos[byte])
  681.               ok = FALSE;
  682.  
  683.           mask = 0;
  684.           for (bit=0;bit<=cmos_item_array[item].end_bit;bit++)
  685.             mask |= (1<<bit);
  686.           if ((preferred_cmos[cmos_item_array[item].end_byte] & mask) != (current_cmos[cmos_item_array[item].end_byte] & mask))
  687.             ok = FALSE;
  688.         }
  689.  
  690.       cmos_item_array[item].cmos_error = NULL;
  691.       if (!ok)
  692.         set_error_message (item,cmos_item_array[item].name);
  693.     }
  694.  
  695.   /* count the changes */
  696.   *changes = 0;
  697.   for (item=0;strlen(cmos_item_array[item].name)!=0;item++)
  698.     if (cmos_item_array[item].cmos_error)
  699.       *changes = *changes + 1;
  700. }
  701.  
  702. void get_screen_size (int *x, int *y)
  703. {
  704.   _kernel_swi_regs reg;
  705.   int X, Y, XE, YE;
  706.  
  707.   reg.r[0] = -1;
  708.   reg.r[1] = 11;
  709.   _kernel_swi (OS_ReadModeVariable,®,®);
  710.   X = reg.r[2] + 1;
  711.  
  712.   reg.r[0] = -1;
  713.   reg.r[1] = 12;
  714.   _kernel_swi (OS_ReadModeVariable,®,®);
  715.   Y = reg.r[2] + 1;
  716.  
  717.   reg.r[0] = -1;
  718.   reg.r[1] = 4;
  719.   _kernel_swi (OS_ReadModeVariable,®,®);
  720.   XE = 1<<reg.r[2];
  721.  
  722.   reg.r[0] = -1;
  723.   reg.r[1] = 5;
  724.   _kernel_swi (OS_ReadModeVariable,®,®);
  725.   YE = 1<<reg.r[2];
  726.  
  727.   *x = X*XE;
  728.   *y = Y*YE;
  729. }
  730.  
  731. void redo_viewer(wimp_redrawstr r)
  732. {
  733.   int item;
  734.   int x, y;
  735.  
  736.   x = r.box.x0-r.scx+10;
  737.   y = r.box.y1-r.scy-10;
  738.  
  739.   for (item=0;strlen(cmos_item_array[item].name)!=0;item++)
  740.     if (cmos_item_array[item].cmos_error)
  741.       {
  742.         bbc_move (x, y);
  743.         printf ("%s",cmos_item_array[item].cmos_error);
  744.         y = y - 36;
  745.       }
  746. }
  747.  
  748.  
  749. void redraw_viewer (wimp_openstr o)
  750. {
  751.   wimp_redrawstr r;
  752.   BOOL more;                
  753.  
  754.   r.w = o.w;
  755.   wimpt_noerr(wimp_redraw_wind(&r, &more));
  756.           
  757.   while (more)
  758.   {  
  759.      if (r.w==cmos_items_handle)
  760.        redo_viewer(r);                
  761.      wimpt_noerr(wimp_get_rectangle(&r, &more));
  762.   }
  763. }
  764.  
  765. void get_input_focus(void)
  766. {
  767.   wimp_caretstr caret;
  768.  
  769.   caret.w = control_handle;
  770.   caret.i = -1;
  771.   caret.x = 0;
  772.   caret.y = 0;
  773.   caret.height = 1<<25;
  774.   caret.index = -1;
  775.       
  776.   wimpt_complain(wimp_set_caret_pos(&caret));
  777. }
  778.  
  779.  
  780. void recollate_changes_to_cmos ( void )
  781. {
  782.   wimp_wind *w;
  783.   wimp_redrawstr r;
  784.   int cmos_changes;
  785.  
  786.   collate_changes_to_cmos (current_cmos,preferred_cmos,&cmos_changes);  
  787.  
  788.   w = template_syshandle("CMOS_Items");
  789.  
  790.   r.w = cmos_items_handle;
  791.   r.box.x0 = w->ex.x0;
  792.   r.box.x1 = w->ex.x1;
  793.   r.box.y0 = min(w->box.y0-w->box.y1+2,-(10+(cmos_changes*36)));
  794.   r.box.y1 = 0;
  795.  
  796.   wimpt_complain (wimp_set_extent(&r));
  797.  
  798.   {
  799.     wimp_wstate s;
  800.  
  801.     wimpt_noerr(wimp_get_wind_state(cmos_items_handle, &s));
  802.     wimpt_noerr(wimp_open_wind(&s.o));
  803.   }
  804.  
  805.   wimpt_noerr(wimp_force_redraw(&r));
  806.  
  807.  
  808. /*
  809.   r.w = control_handle;
  810.   dbox_setfield ((dbox)(r.w),3,"REBOOT");
  811.   wimpt_noerr(wimp_force_redraw(&r));
  812. */
  813. }
  814.  
  815. /****************************** MENU **************************************/
  816.  
  817. menu CMOS_CHK_Menu;
  818.  
  819. typedef enum { menu_INFO=1,
  820.                menu_IGNORE,
  821.                menu_SAVE
  822.              } main_menu_choices;
  823.  
  824. menu Ignore_Menu;
  825.  
  826. void set_menu_flags ()
  827. { 
  828.   int i;
  829.                                                       
  830.   for (i=0;i<=31;i++)
  831.     {
  832.       if (strlen(get_ignore_name(i))!=0)
  833.         menu_setflags (Ignore_Menu, i+1, (prog_settings & (1<<i)), FALSE);
  834.     }
  835. }
  836.  
  837. void MenuEventHandler (void *handle, char *hit)
  838. {                                    
  839.   UNUSED (handle);
  840.  
  841.   switch(hit[0])
  842.     {
  843.       case menu_INFO:
  844.         {
  845.           dbox  InfoDbox;
  846.  
  847.           if ((InfoDbox = dbox_new("ProgInfo")) != NULL)
  848.           {
  849.             dbox_setfield(InfoDbox,0,Task_Name);
  850.             dbox_setfield(InfoDbox,1,msgs_lookup("DESC:CMOS Ram controller"));
  851.             dbox_setfield(InfoDbox,2,"Paul Denize");
  852.             dbox_setfield(InfoDbox,3,msgs_lookup("VERS:Version Unknown"));
  853.             dbox_show(InfoDbox);
  854.             dbox_fillin(InfoDbox);
  855.             dbox_dispose(&InfoDbox);
  856.           }
  857.         }
  858.         break;
  859.  
  860.       case menu_IGNORE:
  861.         {
  862.           prog_settings ^= (1<<(hit[1]-1));
  863.           set_menu_flags ();
  864.           recollate_changes_to_cmos ();
  865.         }
  866.         break;
  867.  
  868.       case menu_SAVE:
  869.         save_prog_settings (prog_settings);       
  870.         break;
  871.     }
  872.  
  873. }
  874.  
  875.  
  876. typedef enum { Continue_Icon    = 1,
  877.                Save_Icon,
  878.                Reset_Icon
  879.              } cmos_control_window_icons;
  880.  
  881. void main_buttonpress(wimp_mousestr *m)
  882. {
  883.   switch (m->bbits & (wimp_BLEFT|wimp_BMID|wimp_BRIGHT))
  884.     {
  885.       case wimp_BLEFT:
  886.         switch (m->i)
  887.           {
  888.             case Continue_Icon:
  889.               exit(0);
  890.               break;
  891.             case Save_Icon:
  892.               save_cmos_preferences (current_cmos);
  893.               exit(0);
  894.               break;
  895.             case Reset_Icon:
  896.               { 
  897.                 BOOL reset_required = FALSE;
  898.                 int item;
  899.                 os_error err;                  
  900.                 wimp_errflags errflags = (wimp_EOK + 16); 
  901.                  char mess[100];
  902.  
  903.  
  904.                 for (item=0;(strlen(cmos_item_array[item].name)!=0) && (!reset_required);item++)
  905.                   reset_required = ((cmos_item_array[item].cmos_error) && (cmos_item_array[item].needs_reset));
  906.  
  907.                 modify_cmos (current_cmos,preferred_cmos);
  908.  
  909.                 err.errnum = 0;
  910.                 sprintf (mess,"%s %s",msgs_lookup("MESS:Message from"),Task_Name);
  911.                 if (reset_required) 
  912.                   strcpy(err.errmess,msgs_lookup("MSG1:CMOS has been altered, Some settings may require a reset before they will take effect"));
  913.                 else
  914.                   strcpy(err.errmess,msgs_lookup("MSG2:CMOS has been altered, No reset required"));
  915.                 wimpt_noerr(wimp_reporterror (&err,errflags,mess));
  916.                 exit(0);
  917.               }
  918.               break;
  919.           }
  920.         get_input_focus();
  921.         break;
  922.     }
  923. }
  924.      
  925. #define Escape_Key 0x1B
  926. #define Return_Key 0x0D
  927.  
  928. void main_keypress ( int chcode )
  929. {
  930.   switch (chcode)
  931.     {
  932.       case Escape_Key:
  933.         exit(0);
  934.         break;
  935.       case Return_Key:
  936.         exit(0);
  937.         break;
  938.     }
  939.   wimp_processkey (chcode);
  940. }
  941.  
  942. void send_help_reply (wimp_msgstr* msg)
  943. {
  944.   msg->hdr.your_ref = msg->hdr.my_ref;
  945.   msg->hdr.action = wimp_MHELPREPLY;
  946.   msg->hdr.size = 256;
  947.   
  948.   switch (msg->data.helprequest.m.i)
  949.   {
  950.     case 1: /* Continue icon */
  951.       sprintf(msg->data.helpreply.text, msgs_lookup("HE1:This is the CONTINUE button.|M\\Scontinue with system as it is."));
  952.       break;
  953.  
  954.     case 2: /* Save icon */
  955.       sprintf(msg->data.helpreply.text, msgs_lookup("HE2:This is the SAVE button.|M\\Ssave current settings as your preferred settings."));
  956.       break;
  957.  
  958.     case 3: /* Reset icon */
  959.       sprintf(msg->data.helpreply.text, msgs_lookup("HE3:This is the RESET button.|M\\Sreset the CMOS to the stored preferred settings."));
  960.       break;        
  961.  
  962.     default:
  963.       sprintf(msg->data.helpreply.text, msgs_lookup("HE4:This is the Check_CMOS alert window.|MCMOS items that are not set to the values you selected as preferred are indicated here."));
  964.       break;
  965.    }
  966.   wimpt_noerr(wimp_sendmessage(wimp_ESEND, msg, msg->hdr.task));
  967. }
  968.  
  969. void recentre_windows ( void )
  970. {
  971.   wimp_wstate s;
  972.  
  973.   wimpt_noerr(wimp_get_wind_state(control_handle, &s));
  974.   {
  975.     int screenx, screeny;
  976.     
  977.     get_screen_size (&screenx, &screeny);
  978.     {
  979.       int middle1;
  980.       int middle2;
  981.       int dx;
  982.       int dy;
  983.       
  984.       middle1 = screenx/2;
  985.       middle2 = s.o.box.x0 + ((s.o.box.x1-s.o.box.x0)/2);
  986.       dx = middle1 - middle2;
  987.  
  988.       middle1 = screeny/2;
  989.       middle2 = s.o.box.y0 + ((s.o.box.y1-s.o.box.y0)/2);
  990.       dy = middle1 - middle2;
  991.  
  992.       s.o.box.x0 += dx;
  993.       s.o.box.x1 += dx;
  994.       s.o.box.y0 += dy;
  995.       s.o.box.y1 += dy;
  996.     }
  997.   }
  998.   wimpt_noerr(wimp_open_wind(&s.o));
  999.  
  1000.   {
  1001.     wimp_wstate s2;
  1002.      
  1003.     wimpt_noerr(wimp_get_wind_state(cmos_items_handle, &s2));
  1004.     {
  1005.       int middle1 = s.o.box.x0 + ((s.o.box.x1-s.o.box.x0)/2);
  1006.       int middle2 = s2.o.box.x0 + ((s2.o.box.x1-s2.o.box.x0)/2);
  1007.       int dx = middle1 - middle2 - 20;
  1008.       int dy = 116 - (s2.o.box.y0 - s.o.box.y0);
  1009.              
  1010.       s2.o.box.x0 += dx;
  1011.       s2.o.box.x1 += dx;
  1012.       s2.o.box.y0 += dy;
  1013.       s2.o.box.y1 += dy;  
  1014.     }
  1015.     wimpt_noerr(wimp_open_wind(&s2.o));
  1016.   }                  
  1017. }
  1018.  
  1019. void control_event_handler(wimp_eventstr *e, void *handle)    /* event handler */
  1020. {
  1021.  
  1022.   handle = handle;
  1023.  
  1024.   switch (e->e)
  1025.   {
  1026.     case wimp_ENULL:
  1027.       event_setmask(event_getmask()|wimp_EMNULL);
  1028.       recentre_windows();
  1029.       break;
  1030.  
  1031.     case wimp_EREDRAW:
  1032.       redraw_viewer(e->data.o);
  1033.       break;
  1034.  
  1035.     case wimp_EOPEN:
  1036.       {
  1037.         wimp_wstate s;
  1038.         
  1039.         if (e->data.o.w == control_handle)
  1040.           {
  1041.             wimpt_noerr(wimp_get_wind_state(cmos_items_handle, &s));
  1042.             s.o.behind = e->data.o.behind;
  1043.  
  1044.             {
  1045.               int middle1 = e->data.o.box.x0 + ((e->data.o.box.x1-e->data.o.box.x0)/2);
  1046.               int middle2 = s.o.box.x0 + ((s.o.box.x1-s.o.box.x0)/2);
  1047.               int dx = middle1 - middle2 - 20;
  1048.               int dy = 116 - (s.o.box.y0 - e->data.o.box.y0);
  1049.              
  1050.               s.o.box.x0 += dx;
  1051.               s.o.box.x1 += dx;
  1052.               s.o.box.y0 += dy;
  1053.               s.o.box.y1 += dy;  
  1054.             }                  
  1055.  
  1056.             wimpt_noerr(wimp_open_wind(&s.o));
  1057.  
  1058.             e->data.o.behind = cmos_items_handle;
  1059.           }
  1060.         else
  1061.           {
  1062.             wimpt_noerr(wimp_get_wind_state(cmos_items_handle, &s));
  1063.             e->data.o.box = s.o.box; /* not Movable */
  1064.             e->data.o.behind = s.o.behind; /* non Orderable */
  1065.           }
  1066.        }
  1067.       wimpt_noerr(wimp_open_wind(&e->data.o));
  1068.       break;
  1069.  
  1070.     case wimp_ECLOSE:
  1071.       win_register_event_handler(control_handle, 0, 0);
  1072.       wimpt_noerr(wimp_delete_wind(control_handle));
  1073.       win_activedec();
  1074.       break;
  1075.  
  1076.     case wimp_EBUT:   
  1077.       main_buttonpress(&e->data.but.m);
  1078.       break;
  1079.  
  1080.     case wimp_EKEY:
  1081.       main_keypress(e->data.key.chcode);
  1082.       break;
  1083.  
  1084.     case wimp_ESEND:
  1085.     case wimp_ESENDWANTACK:    
  1086.       switch(e->data.msg.hdr.action)
  1087.       {
  1088.         case wimp_MMODECHANGE:
  1089.           event_setmask(event_getmask()&~wimp_EMNULL);
  1090.           break;                    
  1091.  
  1092.         case wimp_MHELPREQUEST:
  1093.           send_help_reply(&e->data.msg);
  1094.           break;
  1095.       }
  1096.    }
  1097. }
  1098.  
  1099. void get_task_name (char *name)
  1100. {
  1101.   char obey_dir[256];
  1102.   char *leaf;
  1103.  
  1104.   os_read_var_val("Obey$Dir",obey_dir,sizeof(obey_dir));
  1105.  
  1106.   leaf = obey_dir;
  1107.  
  1108.   while (strchr(leaf,'.')!=0)
  1109.     {
  1110.       leaf = strchr(leaf,'.')+2;
  1111.     }
  1112.      
  1113.   strcpy(name,leaf);
  1114. }
  1115.  
  1116. void alert_user_of_changes (void)
  1117. {
  1118.   int cmos_changes;
  1119.  
  1120.   init_cmos_array ();
  1121.  
  1122.   read_prog_settings (&prog_settings);
  1123.  
  1124.   collate_changes_to_cmos (current_cmos,preferred_cmos,&cmos_changes);
  1125.  
  1126.   if (cmos_changes)
  1127.    {
  1128.     wimp_wind *w;
  1129.     wimp_wstate s;
  1130.  
  1131.     get_task_name (Task_Name);
  1132.     wimpt_init(Task_Name);
  1133.     resspr_init();
  1134.     template_init();
  1135.  
  1136.     if ((w = template_syshandle("CMOS_Items")) == 0)
  1137.       werr (FALSE, msgs_lookup ("ER1:Template \"CMOS_Items\" not found"));
  1138.  
  1139.     w->ex.y0 = min(w->box.y0-w->box.y1+2,-(10+(cmos_changes*36)));
  1140.     w->ex.y1 = 0;
  1141.  
  1142.     wimpt_noerr(wimp_create_wind(w, &cmos_items_handle));
  1143.     wimpt_noerr(wimp_get_wind_state(cmos_items_handle, &s));
  1144.     s.o.behind = -1;
  1145.     wimpt_noerr(wimp_open_wind(&s.o));
  1146.  
  1147.     if ((w = template_syshandle("Control")) == 0)
  1148.       werr (FALSE, msgs_lookup ("ER0:Template \"Control\" not found"));
  1149.  
  1150.     wimpt_noerr(wimp_create_wind(w, &control_handle));
  1151.     wimpt_noerr(wimp_get_wind_state(control_handle, &s));
  1152.     s.o.behind = cmos_items_handle;
  1153.     wimpt_noerr(wimp_open_wind(&s.o));
  1154.                                   
  1155.     recentre_windows();
  1156.  
  1157.     win_claim_unknown_events(cmos_items_handle);
  1158.     win_claim_unknown_events(control_handle);
  1159.     win_activeinc();
  1160.  
  1161.     win_register_event_handler(control_handle, control_event_handler, 0);
  1162.     win_register_event_handler(cmos_items_handle, control_event_handler, 0);
  1163.     {                                      
  1164.       char menustr[200];
  1165.       sprintf (menustr,">%s,%s,%s", msgs_lookup("MENU0:Info"), 
  1166.                                     msgs_lookup("MENU1:Ignore"), 
  1167.                                     msgs_lookup("MENU2:Save Options"));
  1168.       CMOS_CHK_Menu = menu_new(Task_Name,menustr);
  1169.     }
  1170.     {                                      
  1171.       char menustr[200] = "";
  1172.       int i;
  1173.    
  1174.       for(i=0;i<=31;i++)
  1175.         {
  1176.           char *ignore_name;
  1177.  
  1178.           ignore_name = get_ignore_name(i);
  1179.           if (strlen(ignore_name)!=0)
  1180.             {
  1181.               strcat (menustr,",");
  1182.               strcat(menustr,ignore_name);
  1183.             }
  1184.         }
  1185.       Ignore_Menu = menu_new(msgs_lookup("MENU1:Ignore"),menustr);
  1186.     }
  1187.     menu_submenu (CMOS_CHK_Menu,menu_IGNORE,Ignore_Menu);
  1188.     set_menu_flags ();
  1189.     event_attachmenu(cmos_items_handle, CMOS_CHK_Menu, MenuEventHandler, NULL); 
  1190.     event_attachmenu(control_handle, CMOS_CHK_Menu, MenuEventHandler, NULL); 
  1191.  
  1192.     get_input_focus();
  1193.  
  1194.     event_setmask(event_getmask()|wimp_EMPTRLEAVE
  1195.                                  |wimp_EMPTRENTER);
  1196.  
  1197.     while (TRUE)
  1198.       event_process();
  1199.   }
  1200. }
  1201.  
  1202.  
  1203. int main ()
  1204. {
  1205.   BOOL cmos_changed;
  1206.  
  1207.   res_init("CheckCMOS");
  1208.   msgs_init();
  1209.   read_cmos (¤t_cmos);
  1210.   if (!file_exists(CMOS_preferences))
  1211.     save_cmos_preferences (current_cmos);
  1212.   else
  1213.     {
  1214.       read_cmos_preferences (&preferred_cmos);
  1215.       perform_cmos_check(&cmos_changed);
  1216.       if (cmos_changed)
  1217.         alert_user_of_changes ();
  1218.     }
  1219.  
  1220.   return 0;
  1221. }
  1222.